packages/vue-i18n-core/src/i18n.ts (1)

566-610: Consider extracting shared composer lifecycle wiring for isolated and local paths.

Lines 570–607 duplicate composer extension, devtools emitter setup, and disposal logic also present in the local branch, which increases drift risk.

♻️ Suggested refactor sketch

+function setupComposerLifecycle(
+  i18nInternal: I18nInternal,
+  composer: Composer
+): void {
+  if (i18nInternal.__composerExtend) {
+    ;(composer as any)[DisposeSymbol] = i18nInternal.__composerExtend(composer)
+  }
+  let emitter: VueDevToolsEmitter | null = null
+  if ((__DEV__ || __FEATURE_PROD_VUE_DEVTOOLS__) && !__NODE_JS__) {
+    emitter = createEmitter<VueDevToolsEmitterEvents>()
+    const _composer = composer as any
+    _composer[EnableEmitter]?.(emitter)
+    emitter.on('*', addTimelineEvent)
+  }
+  const currentScope = getCurrentScope()
+  if (currentScope) {
+    onScopeDispose(() => {
+      if ((__DEV__ || __FEATURE_PROD_VUE_DEVTOOLS__) && !__NODE_JS__) {
+        emitter?.off('*', addTimelineEvent)
+        const _composer = composer as any
+        _composer[DisableEmitter]?.()
+      }
+      const dispose = (composer as any)[DisposeSymbol]
+      if (dispose) {
+        dispose()
+        delete (composer as any)[DisposeSymbol]
+      }
+    })
+  }
+}

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/vue-i18n-core/src/i18n.ts` around lines 566 - 610, The isolated
branch duplicates lifecycle/devtools wiring (composer extension, devtools
emitter setup, and onScopeDispose teardown) that also exists in the local
branch; extract that shared logic into a helper (e.g., wireComposerLifecycle or
setupComposerLifecycle) and call it from both paths. The helper should accept
the created composer and I18nInternal (to run __composerExtend and store
DisposeSymbol), create and enable the devtools emitter (using createEmitter,
EnableEmitter/DisableEmitter, and emitter.on/off with addTimelineEvent) only
when (__DEV__ || __FEATURE_PROD_VUE_DEVTOOLS__) && !__NODE_JS__, and register
the same onScopeDispose teardown to remove the emitter listener, disable
emitter, and call/delete the DisposeSymbol; replace the duplicated blocks in
createComposer call sites (where composer is created and where DisposeSymbol,
EnableEmitter, DisableEmitter, emitter, __composerExtend, and onScopeDispose are
referenced) with a call to this helper.

packages/vue-i18n-core/test/i18n.test.ts (1)

463-503: Add a same-key collision regression test for local vs isolated scopes.

The current test (lines 463-503) uses different keys across scopes (hi in local, status in isolated). Add a test where both scopes use the same key to verify that isolated scope properly isolates from local scope when keys collide—this closes a regression gap.

Suggested test case

+    test('isolated scope does not collide with local scope on same key', async () => {
+      const i18n = createI18n({
+        locale: 'en',
+        messages: { en: { status: 'from global' } }
+      })
+
+      let localComposer: Composer
+      let isolatedComposer: Composer
+      const App = defineComponent({
+        setup() {
+          localComposer = useI18n({
+            messages: { en: { status: 'from local' } }
+          }) as Composer
+          isolatedComposer = useI18n({
+            useScope: 'isolated',
+            messages: { en: { status: 'from isolated' } }
+          }) as Composer
+          return {}
+        },
+        template: `<p>foo</p>`
+      })
+      await mount(App, i18n)
+
+      expect(localComposer.t('status')).toEqual('from local')
+      expect(isolatedComposer.t('status')).toEqual('from isolated')
+    })

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/vue-i18n-core/test/i18n.test.ts` around lines 463 - 503, Add a
regression test that verifies isolated composable scopes truly isolate when keys
collide with local/component scope: duplicate the existing "coexists with local
scope" test pattern but use the same key name in the component local useI18n and
in the isolated composable useI18n (e.g., both use 'status' or 'hi') and assert
the component Composer.t('status') (or 'hi') returns the component message while
the composableResult.status returns the isolated message; reference the same
functions and symbols (createI18n, useI18n with useScope: 'isolated',
useMyComposable, localComposer variable, composableResult, Composer, and App) so
the new test sits alongside the existing one and ensures collision isolation.

Configuration used: defaults

Review profile: CHILL

Plan: Pro